dnd: Guard drags with a reference when finishing

Usually the "dnd-finished" signal will be used to unref the GdkDrag. In
those cases, we would lose the object, so that when we do the final
drag_drop_done() afterwards, we wouldn't have a remaining reference.

With the reference guard, this now works.

glx: Get rid fo DrawableInfo

Store the frame counter in the surface, where it belongs.

gdkdisplay-win32.c: Don't call ReleaseDC() unnecessarily

The dummy Win32 window that we use to capture display change events and
to create dummy WGL contexts was created with CS_OWNDC, so we really do
not need to (and should not) call ReleaseDC() on the HDC that we
obtained from it, so drop these calls.

GDK-Win32: init_gl(): Default to WGL for now

Since the shaders need to be updated for using with GLES (libANGLE at
least), default to WGL for now.  Unfortunately it is not that common for
Windows to have GLES support, in which the easiest way to obtain such
support is via Google's libANGLE.

GDK-Win32: Fixup, and cleanup WGL HDC handling

It turns out that the problem of the WGL window not drawing was due to
the fact that I messed up where I placed SwapBuffers() during the
conversion... doh:|

At the same time, stop storing the HDC in the GdkWin32GLContextWGL, but
instead always create it along the surface we created, so that it is ready
for use for operating with WGL when we are not dealing with "surfaceless"
contexts.  If we are dealing with "surfaceless" contexts, just use the
HDC of the dummy window that we created when we created the
Gdk(Win32)Display.

WGL contexts should now be in working order at this point.

Split out WGL/EGL stuff and simplify things

This commit attempts to split GdkWin32GLContext into two parts, one for
WGL and the other for EGL (ANGLE), and attempts to simplify things a
bit, by:

*  We are already creating a Win32 window to capture display changes,
   so we can just use that to act as our dummy window that we use to
   find out the pixel format that the system supports for WGL.  We also
   use it to obtain the dummy legacy WGL context that we will always
   require to create our more advanced Core WGL contexts.

*  Like what is done in X11, store up the WGL pixel format or the
   EGLConfig in our GdkWin32Display.

*  Ensure we do not create the dummy WGL context unnecessarily.

In this way, we can successfully create the WGL/EGL contexts, however
there are some issues at this point:

*  For WGL, the code successfully initializes and realizes the WGL
   Contexts, but for some reason things became invisible.  When running
   gtk4-demo, this can be verified by seeing the mouse cursor changing
   when moved to spots where one can resize the window, although they
   were invisible.

*  For EGL, the code initializes EGL but could not realize the EGL
   context as shaders failed to compile.  It seems like the shader issue
   is definitely outside the scope of this MR.

gl: Fix issue with EGL + nvidia

nvidia sets the default draw buffer to GL_NONE if EGL contexts are
initially bound to EGL_NO_SURFACE which is exactly what we are doing. So
bind them to GL_BACK when drawing, as they should be.

See https://phabricator.services.mozilla.com/D118743 for a discussion
about EGL_NO_CONTEXT and draw buffers.

GDK: Add debug option for WGL usage

This way, one can force using WGL on Windows even if EGL support was
enabled.  Also update the help text for gl-egl as it will apply for
Windows, albeit a bit later.

GDK-Win32: Move some functions out of gdkglcontext-win32.c

We want these to be out of the way as we split between WGL and EGL/ANGLE
GL contexts, so that they don't get in the way.

display: Move GL selection code into gdkdisplay-x11.c

This has the benefit that we can refactor it and make sure we deal with
GdkDisplay::init_gl() not being called at all because
GDK_DEBUG=gl-disable had been specified.

x11: Move code from GdkGLContextX11

It's not used there, but both backends have independent
immplementationgs for it.

I want to get rid of GdkGLContextX11 and moving code from it is the
first step.

inspector: Add support for displaying GL errors

Also, no need to show a GL version if GL isn't available.

gdk: Move GL context construction to GdkGLContext

Now that we have the display's context to hook into, we can use it to
construct other GL contexts and don't need a GdkSurface vfunc anymore.

This has the added benefit that backends can have different GdkGLContext
classes on the display and get new GLContexts generated from them, so
we get multiple GL backend support per GDK backend for free.

I originally wanted to make this a vfunc on GdkGLContextClass, but
it turns out all the abckends would just call g_object_new() anyway.

gl: Move vfunc

Instead of
  Display::make_gl_context_current()
we now have
  GLContext::clear_current()
  GLContext::make_current()

This fits better with the backends (we can actually implement
clearCurrent on macOS now) and makes it easier to implement different GL
backends for backends (like EGL/GLX on X11).

We also pass a surfaceless boolean to make_current() so the calling code
can decide if a surface needs to be bound or not, because the backends
were all doing whatever, which was very counterproductive.

gl: Require EGL_KHR_surfaceless_context with egl

The code to create and manage a fake egl surface to bind to is
complex and completely untested because everyone seems to support this
extension.

nvidia and Mesa do support it and according to Mesa devs, adding support
in a new driver is rather simple and Mesa drivers gain that feature
automatically, so all future drivers shoould have it.

gdk: Get rid of paint contexts

... or more exactly: Only use paint contexts with
gdk_cairo_draw_from_gl().

Instead of paint contexts being the only contexts who call swapBuffer(),
any context can be used for this, when it's used with
begin_frame()/end_frame().

This removes 2 features:

1. We no longer need a big sharing hierarchy. All contexts are now
   shared with gdk_display_get_gl_context().
2. There is no longer a difference between attached and non-attached
   contexts. All contexts work the same way.

gl: Store the context::in-frame state in the current context

Do not treat the context as already current when the value
of context::in-frame changes.

This is so we can bind to EGL_NO_SURFACE if context::in-frame == false
and to context::surface if context::in-frame == true.

This allows getting rid of the attached property in future commits.

gl: Deprecate gdk_gl_context_get_shared_context()

It's not used anymore. And in particular we do want to keep the display
context private, so we're not gonna return it from this function.

gdk: Add gdk_gl_context_is_shared()

... and use it in the GL renderers.

ngl: Store the shared driver in the display

... instead of some random GL context.

gdk: Require EGL version 1.4 across the board

Mesa currently ships 1.5.

gdk: Add GdkDisplay::init_gl vfunc

The vfunc is called to initialize GL and it returns a "base" context
that GDK then uses as the context all others are shared with. So the GL
context share tree now looks like:

+ context from init_gl
  - context1
  - context2
  ...

So this is a flat tree now, the complexity is gone.

The only caveat is that backends now need to create a GL context when
initializing GL so some refactoring was needed.

Two new functions have been added:

* gdk_display_prepare_gl()
  This is public API and can be used to ensure that GL has been
  initialized or if not, retrieve an error to display (or debug-print).
* gdk_display_get_gl_context()
  This is a private function to retrieve the base context from
  init_gl(). It replaces gdk_surface_get_shared_data_context().

wayland: Don't pass GL config to get_egl_surface()

There's only one GL config.

wayland: Move fbconfig into the display

Create it during init and then reuse it for all contexts.

While doing that, also improve error reporting - that's not used yet but
will in later commits.

gdk: Allow GdkDrawContext with a %NULL surface

This is not used yet, but it allows surfaceless GL contexts.

For that purpose, we need to make the display a construct-only property,
so that it can be set when the surface isn't.

This adds a bunch of very picky checks in the constructor so nothing bad
can happen.

gdk: Add a private struct to GdkDisplay

... and move some members from the GdkDisplay struct.

We've always wanted to add one to isolate the display from the backends
a bit more, but so far it's never happened.

Now that I'm about to add more data to GdkDisplay, it's a good excuse to
start.

x11: Redo choice between EGL and GLX

We try EGL first, but are very picky about what we accept.
If that fails, we try to go with GLX instead.
And if that also fails, we try EGL again, but this time accept anything.

The idea here is that EGL is the preferred method going forward, but GLX is
the tried and tested method that we know works. So if we detect issues with
EGL, we want to avoid using it in favor of GLX.

Also add a GDK_DEBUG=gl-egl option to force EGL at all costs and not try
GLX.

x11: Properly record the error when initializing GL

That way, we can give a useful error message when things break down for
users.

These error messages could still be improved in places (like looking at
the actual EGL error codes), but that seemed overkill.

x11: Do not call glXQueryExtension()

epoxy does that already.

x11: Get Visual from EGL directly

Query the EGL_VISUAL_ID from the egl Config and select a config with the
matching Visual.

This is currently broken on Mesa because it does not expose any RGBA
X Visuals in any EGL config, so we always end up with opaque Windows.

https://gitlab.freedesktop.org/mesa/mesa/-/issues/149

x11: Store the GLX drawable in the surface

Also, stop using a dummy window for unattached GL contexts and instead
use the display's leader surface.

Again, this mirrors EGL.

x11: Use single GLX fbconfig and store it in the display

This mirrors the code for the EGL config.

x11: Remove glx version check

We only work with GLX >= 1.3 anyway, so don't explicitly check for it
and pretend to do something else that doesn't work otherwise.

x11: Remove unused struct member

We don't care if the GL context is direct at all.

Revert "x11: Always fall back to GLX on NVIDIA"

This reverts commit c35a6725b99722d91b0ed6580546c27c8f0849ba.

This approach doesn't work because if NVIDIA doesn't work for EGL, the
EGL implementation won't be provided by NVIDIA, so checking the vendor
doesn't work.

x11: Remove the dummy surface

Instead, use the display's "leader surface" when no surface is required,
because we have it lying around.

Really, we want to use EGL_NO_SURFACE, but if that's not supported...

x11: Remove GdkVisual

It's not used anymore.

x11: Rework Visual selection

Instead of going via GdkVisual, doing a preselection and letting the GL
initialization improve it, let the GL initialization pick an X Visual
directly using X Visual code directly.

The code should select the same visuals as before as it tries to apply
the same logic, but it's a rewrite, so I expect I messed something up.

glx: Remove Visual cache

1. We're using EGL most of the time anyway, so if we wanted to cache
   things, we'd need to port it there.
2. Our GL handling is massively configurable, so determining when to use
   the cache and when not is a challenge.
3. It makes startup nondeterministic and depend on whether a GTK4 app
   has previously been started on this display and nobody thinks about
   that when debugging.
4. The only benefit of the caching is delaying GL initialization - which
   made sense in GTK3 where almost no app used GL but doesn't make sense
   in GTK4 where almost every app uses GL.

So unless I find a big benefit to reintroducing it, this cache will be
gone for good.

x11: Move GL init code into the GL context

No functional changes, just shuffling code.

x11: Store the EGL surface in the GdkSurfaceX11

Avoids having to use private data, though the benefit is somewhat
limited as we still have to put the destructor in the egl code and can't
just put it in gdk_surface_x11_finalize().

x11: Store the EGL config in the display

We only have one config, because we use the same Visual everywhere.
Store this config in the GdkDisplayX11 struct for easy access.

Also do this on initialize, because if creating the config fails, we
want to switch to GLX instead of failing to do GL at all.

This also simplifies a lot of code as we can share Visual, Colormap, etc
across surfaces.

x11: Move the EGL display into the private struct

There's no need to use g_object_set_data() for it.

We can also stop caching it elsewhere because we know the display has
it.

And finally, we can remove the display->have_egl boolean and use
display->egl_display != NULL instead. We initialize the display at
startup, so that variable is the perfect indicator.

x11: Pass the display, not the screen

Screens are on their way out.

x11: Simplify code

These variables were a lot more important in GTK3, but now we just want
to pass them through to X.

x11: Move function call

The GLX visual selection is GLX specific, so it can be handled by the GLX
code.

There should be no reordering here, the call was just moved.

glx: Don't initialize GLX multiple times.

Either it is initialized or it isn't.

x11: Initialize GL at startup

We need to initialize GL to select the Visual we are going to use for
all our Windows.

As the Visual needs to be known before we know if we are even gonna use
GL later, we can't avoid initializing it.

Note that this previously happened, too. It was just hidden behind the
GdkScreen initialization.

x11: Don't share cached GLX visuals with GTK3

We don't want to bind ourselves to GTK3 - both because we don't want to
accidentally cause bugs in a different codebase and because we want to
deviate from it.

While doing so, also store visuals as visuals and not as integers.
And only store one Visual because GTK4 only uses one visual.

And then remove the code that is leftover for dealing with the
compatibility Visual for GTK3.

PS: I'm kinda proud of my STRINGIFY_WITHOUT_BRACKETS hack.

x11: Reorder code

Initialize the GL visuals from gdkdisplay.c so the call into the GL
stack isn't hidden in gdkvisual.c

This is relevant for further commits.

x11: Stop reordering visuals

The old code was ordering visuals by depth, but considering that these
days we either use the default visual or a 32bit RGBA visual, that
reordering does not have an effect anymore.

In theory, the only effect is that the GLX Visual selection might select
a different replacement Visual when it checks for improved GL Visuals, but
even there I can't come up with a case where that matters, because
again, the visuals are only reordered by depth and we want to keep the
depth.

In any case, make this a separate commit so bisecting can find this
problem if it ever shows up.

x11: Remove unused function

Now that we can't create extra GdkX11Screens anymore, this also means
that there is exactly 1 GdkX11Screen per GdkX11Display.

x11: Move code where it belongs

Instead of the display telling the screen to tell the visuals to tell
the display to initialize itself, just init the display directly.

What a concept.

build: Build demos before tools

That's a sneaky trick so my edit/compile/test cycle goes faster:
I usually use demos for testing so the tools don't have to be linked for
me to start testing.

Merge branch 'destroy-pointer-gestures' into 'master'

gdk/wayland: Clean up gestures if pointer capability is withdrawn

See merge request GNOME/gtk!3697

gdk/wayland: Clean up gestures if pointer capability is withdrawn

If the pointer capability is added, pointer swipe and pinch gestures
will be created. However, if the pointer capability is removed, the
gesture objects won't be destroyed.

If the pointer capability is removed and added several times in a row,
for example due to plugging and unplugging physical mouse, this can lead
to leaking the old gesture objects.

In order to prevent that, this change makes the seat destroy swipe and
pinch gestures when the pointer capability is withdrawn.

Merge branch 'sync-icons' into 'master'

Sync included icons from adwaita-icon-theme

See merge request GNOME/gtk!3773

Sync included icons from adwaita-icon-theme

Make sure we stay in sync with the Adwaita.

Merge branch 'wip/otte/build' into 'master'

Streamline build configuration

See merge request GNOME/gtk!3391

x11: Remove XComposite

It's only used during DND to allow use of the root window's cow window
as a DND target, because apparently gnome-shell used to think that was a
great idea to DND to the overview.

Somebody complain to gnome-shell devs about it not being a good idea if
they want it fixed.
Potentially using Wayland is a better idea though.

This reverts 85ae875dcbfcfa3fbdca857dc90467d39b9ff0c5

Related: https://bugzilla.gnome.org/show_bug.cgi?id=601731

x11: Remove unused headers

build: Make all X11 extensions mandatory

It's not 2011 anymore, and we shouldn't randomly build one of 10.000
different combinations of X11 backends (I counted the possibilities) but
exactly the one we expect people to use.

build: Remove sassc option

Instead, ensure that sassc is made madatory on git builds (because
it is, we don't ship CSS files anymore) and not even looked for in
release builds (because do ship CSS files there).

build: disable Vulkan by default

We don't want people to build Vulkan support when they just want to get
GTK built.

This is in particular true for GTK as a CI subproject or for people
using jhbuild.

Worse, just having Vulkan support compiled in tends to cause crashes
in the Inspector, even if you are not using it.

build: Set proper defaults for media backends

GTK supports webm playback, which means a backend should always be
compiled.

The ffmpeg backend however is incomplete (no audio) and as such, we
don't want people to end up with it accidentally.

Since we don't want to drag an entire gstreamer build into our ci
on MacOs or msvc, explicitly disable the gstreame media backend there.

Merge branch 'fix-dialog-docs' into 'master'

gtk/builder: Port example to GTK 4

See merge request GNOME/gtk!3772

Update Ukrainian translation

gtk/builder: Port example to GTK 4

Merge branch 'tooltip-hig' into 'master'

password_entry: Header Capitalization on tooltip

See merge request GNOME/gtk!3771

password_entry: Header Capitalization on tooltip

See https://teams.pages.gitlab.gnome.org/Design/hig-www/feedback/tooltips.html

Merge branch 'win32.hidpi.cleanup' into 'master'

GDK-Win32: Clean up HiDPI support and WGL slightly

Closes #3796

See merge request GNOME/gtk!3767

Merge branch 'ci-default-settings-4' into 'master'

reftests: Enforce default settings

See merge request GNOME/gtk!3769

reftests: Enforce default settings

Set all settings to their default values, so we
are less dependent on the environment to be set
up just right. In particular, this fixes animations
being disabled when we happen to run in a vm.

GDK-Win32: Clean up HiDPI support and WGL a bit

Make _gdk_win32_display_get_monitor_scale_factor() less complex, by:

*  Drop the preceding underscore.

*  Dropping an unused parameter.

*  Using a GdkSurface instead of a HWND, as the HWND that we pass into
   this function might have been taken from a GdkSurface, which are now
   always created with CS_OWNDC.  This means if a GdkSurface was passed
   in, we ensure that we only acquire the DC from the HWND once, and do
   not attempt to call ReleaseDC() on it.

*  Store the HDC that we acquire from the GdkSurface's HWND into the
   surface, and use that as the HDC we need for our GdkGLContext.

*  Drop the gl_hwnd from GdkWin32Display, as that is really should be
   stored in the GdkSurface.

*  For functions that were updated, name GdkWin32Display variables as
   display_win32 and GdkSurface variables as surface, to unify things.

*  Stop calling ReleaseDC() on the HDC that we use for OpenGL, since
   they were acquired from HWND's created with CS_OWNDC.

gdksurface-win32.c: Create all surfaces with CS_OWNDC

We want to ensure that we have things set up properly for drag surfaces
as well.

Merge branch 'pango-main' into 'master'

Use pango from the main branch

See merge request GNOME/gtk!3762

Update Ukrainian translation

Use pango from the main branch

Change the Pango subproject to use the main branch.

This depends on
https://gitlab.gnome.org/GNOME/pango/-/merge_requests/379

Merge branch 'wip/otte/for-master' into 'master'

cssimagecrossfade: Don't abort() when failing to parse image

Closes #4101

See merge request GNOME/gtk!3758

cssimagecrossfade: Don't abort() when failing to parse image

The code wasn't checking if parsing an image failed and just returning
success.

Testcase from bug is attached.

Fixes #4101

Merge branch 'fix-negative-scales' into 'master'

ngl: Handle negative scales

Closes #4096

See merge request GNOME/gtk!3755

Merge branch 'metainfo' into 'master'

metadata: Fix license identifiers and appdata

See merge request GNOME/gtk!3757

testsuite: Avoid negative scales with gl renderer

The fix in 1c90bb522e7e722b was only for the ngl renderer,
so don't use the test with the gl renderer, until it is
fixed as well.

Merge branch 'wip/chergert/fix-texthistory-insert' into 'master'

texthistory: fix calculation of n_chars

See merge request GNOME/gtk!3756

meson: Use a valid SPDX identifier

See https://mesonbuild.com/Reference-manual.html#license

appdata: Use launchable rather than id

<id> should be used for the component id and <launchable> for the
desktop file.

appdata: Add content_rating

https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-content_rating

appdata: Use correct SPDX license identifier

Following
https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-project_license,
for the complete list of identifiers see https://spdx.org/licenses/

texthistory: fix calculation of n_chars

This should be the number of characters, not the end position. This fixes
an issue where we wouldn't coalesce insert actions together.

testsuite: Add test for crasher

Test for the crasher in !4096

ngl: Handle negative scales

Scale factors can be negative, but we were not
looking out for that, triggering an assertion when
trying to create a render target with negative
width of height. Avoid that.

Fixes: #4096

Merge branch 'transparent-optimizations' into 'master'

snapshot: Handle transparent opacity nodes correctly

See merge request GNOME/gtk!3754

Merge branch 'wip/baedert/for-master' into 'master'

snapshot: Replace trivial gradients with color nodes

See merge request GNOME/gtk!3753

ngl: Do nothing for transparent text nodes

Like the previous commit - a transparent text node
will not produce any visible pixels, so bail out early.

ngl: Do nothing for transparent color nodes

No need to send commands to the GPU to render transparency.

snapshot: Handle transparent opacity nodes correctly

Eliding totally transparent content from the node tree is
not 100% correct, since filters can make things visible, so
we need to at least preserve the bounds. We can do that by
creating a transparent color node.

snapshot: Only compute start and end point if we have to

If the linear gradient results in a color node, we don't need the start
and end point. Only declare and compute it if we need to.

snapshot: Replace trivial gradients with color nodes

Extend this to all existing gradient types

Merge branch 'wip/otte/for-master' into 'master'

rendernodeparser: Don't use %g when writing file

See merge request GNOME/gtk!3752

rendernodeparser: Remove leftover debug prints